//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Notifications service.
///
/// The User Notifications API Reference provides descriptions, API request parameters, and the JSON response for each of the User Notifications API actions. User Notification control plane APIs are currently available in US East (Virginia) - us-east-1.  GetNotificationEvent and ListNotificationEvents APIs are currently available in commercial partition Regions and only return notifications stored in the same Region in which they're called. The User Notifications console can only be used in US East (Virginia). Your data however, is stored in each Region chosen as a notification hub in addition to US East (Virginia).  For information about descriptions, API request parameters, and the JSON response for email contact related API actions, see the User Notifications Contacts API Reference Guide.
public struct Notifications: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Notifications client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Notifications",
            serviceIdentifier: "notifications",
            serviceProtocol: .restjson,
            apiVersion: "2018-05-10",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            variantEndpoints: Self.variantEndpoints,
            errorType: NotificationsErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "af-south-1": "notifications.af-south-1.api.aws",
        "ap-east-1": "notifications.ap-east-1.api.aws",
        "ap-northeast-1": "notifications.ap-northeast-1.api.aws",
        "ap-northeast-2": "notifications.ap-northeast-2.api.aws",
        "ap-northeast-3": "notifications.ap-northeast-3.api.aws",
        "ap-south-1": "notifications.ap-south-1.api.aws",
        "ap-south-2": "notifications.ap-south-2.api.aws",
        "ap-southeast-1": "notifications.ap-southeast-1.api.aws",
        "ap-southeast-2": "notifications.ap-southeast-2.api.aws",
        "ap-southeast-3": "notifications.ap-southeast-3.api.aws",
        "ap-southeast-4": "notifications.ap-southeast-4.api.aws",
        "ap-southeast-5": "notifications.ap-southeast-5.api.aws",
        "ap-southeast-7": "notifications.ap-southeast-7.api.aws",
        "ca-central-1": "notifications.ca-central-1.api.aws",
        "ca-west-1": "notifications.ca-west-1.api.aws",
        "cn-north-1": "notifications.cn-north-1.api.amazonwebservices.com.cn",
        "cn-northwest-1": "notifications.cn-northwest-1.api.amazonwebservices.com.cn",
        "eu-central-1": "notifications.eu-central-1.api.aws",
        "eu-central-2": "notifications.eu-central-2.api.aws",
        "eu-north-1": "notifications.eu-north-1.api.aws",
        "eu-south-1": "notifications.eu-south-1.api.aws",
        "eu-south-2": "notifications.eu-south-2.api.aws",
        "eu-west-1": "notifications.eu-west-1.api.aws",
        "eu-west-2": "notifications.eu-west-2.api.aws",
        "eu-west-3": "notifications.eu-west-3.api.aws",
        "il-central-1": "notifications.il-central-1.api.aws",
        "me-central-1": "notifications.me-central-1.api.aws",
        "me-south-1": "notifications.me-south-1.api.aws",
        "mx-central-1": "notifications.mx-central-1.api.aws",
        "sa-east-1": "notifications.sa-east-1.api.aws",
        "us-east-1": "notifications.us-east-1.api.aws",
        "us-east-2": "notifications.us-east-2.api.aws",
        "us-gov-east-1": "notifications.us-gov-east-1.api.aws",
        "us-gov-west-1": "notifications.us-gov-west-1.api.aws",
        "us-west-1": "notifications.us-west-1.api.aws",
        "us-west-2": "notifications.us-west-2.api.aws"
    ]}


    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "af-south-1": "notifications-fips.af-south-1.api.aws",
            "ap-east-1": "notifications-fips.ap-east-1.api.aws",
            "ap-east-2": "notifications-fips.ap-east-2.api.aws",
            "ap-northeast-1": "notifications-fips.ap-northeast-1.api.aws",
            "ap-northeast-2": "notifications-fips.ap-northeast-2.api.aws",
            "ap-northeast-3": "notifications-fips.ap-northeast-3.api.aws",
            "ap-south-1": "notifications-fips.ap-south-1.api.aws",
            "ap-south-2": "notifications-fips.ap-south-2.api.aws",
            "ap-southeast-1": "notifications-fips.ap-southeast-1.api.aws",
            "ap-southeast-2": "notifications-fips.ap-southeast-2.api.aws",
            "ap-southeast-3": "notifications-fips.ap-southeast-3.api.aws",
            "ap-southeast-4": "notifications-fips.ap-southeast-4.api.aws",
            "ap-southeast-5": "notifications-fips.ap-southeast-5.api.aws",
            "ap-southeast-6": "notifications-fips.ap-southeast-6.api.aws",
            "ap-southeast-7": "notifications-fips.ap-southeast-7.api.aws",
            "ca-central-1": "notifications-fips.ca-central-1.api.aws",
            "ca-west-1": "notifications-fips.ca-west-1.api.aws",
            "cn-north-1": "notifications-fips.cn-north-1.api.amazonwebservices.com.cn",
            "cn-northwest-1": "notifications-fips.cn-northwest-1.api.amazonwebservices.com.cn",
            "eu-central-1": "notifications-fips.eu-central-1.api.aws",
            "eu-central-2": "notifications-fips.eu-central-2.api.aws",
            "eu-north-1": "notifications-fips.eu-north-1.api.aws",
            "eu-south-1": "notifications-fips.eu-south-1.api.aws",
            "eu-south-2": "notifications-fips.eu-south-2.api.aws",
            "eu-west-1": "notifications-fips.eu-west-1.api.aws",
            "eu-west-2": "notifications-fips.eu-west-2.api.aws",
            "eu-west-3": "notifications-fips.eu-west-3.api.aws",
            "il-central-1": "notifications-fips.il-central-1.api.aws",
            "me-central-1": "notifications-fips.me-central-1.api.aws",
            "me-south-1": "notifications-fips.me-south-1.api.aws",
            "mx-central-1": "notifications-fips.mx-central-1.api.aws",
            "sa-east-1": "notifications-fips.sa-east-1.api.aws",
            "us-east-1": "notifications-fips.us-east-1.api.aws",
            "us-east-2": "notifications-fips.us-east-2.api.aws",
            "us-gov-east-1": "notifications-fips.us-gov-east-1.api.aws",
            "us-gov-west-1": "notifications-fips.us-gov-west-1.api.aws",
            "us-west-1": "notifications-fips.us-west-1.api.aws",
            "us-west-2": "notifications-fips.us-west-2.api.aws"
        ])
    ]}

    // MARK: API Calls

    /// Associates a delivery Channel with a particular NotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, the Console Mobile Application, and emails (notifications-contacts).
    @Sendable
    @inlinable
    public func associateChannel(_ input: AssociateChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateChannelResponse {
        try await self.client.execute(
            operation: "AssociateChannel", 
            path: "/channels/associate/{arn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a delivery Channel with a particular NotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, the Console Mobile Application, and emails (notifications-contacts).
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the Channel to associate with the NotificationConfiguration. Supported ARNs include Amazon Q Developer in chat applications, the Console Mobile Application, and notifications-contacts.
    ///   - notificationConfigurationArn: The ARN of the NotificationConfiguration to associate with the Channel.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateChannel(
        arn: String,
        notificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateChannelResponse {
        let input = AssociateChannelRequest(
            arn: arn, 
            notificationConfigurationArn: notificationConfigurationArn
        )
        return try await self.associateChannel(input, logger: logger)
    }

    /// Associates an Account Contact with a particular ManagedNotificationConfiguration.
    @Sendable
    @inlinable
    public func associateManagedNotificationAccountContact(_ input: AssociateManagedNotificationAccountContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateManagedNotificationAccountContactResponse {
        try await self.client.execute(
            operation: "AssociateManagedNotificationAccountContact", 
            path: "/contacts/associate-managed-notification/{contactIdentifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates an Account Contact with a particular ManagedNotificationConfiguration.
    ///
    /// Parameters:
    ///   - contactIdentifier: A unique value of an Account Contact Type to associate with the ManagedNotificationConfiguration.
    ///   - managedNotificationConfigurationArn: The Amazon Resource Name (ARN) of the ManagedNotificationConfiguration to associate with the Account Contact.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateManagedNotificationAccountContact(
        contactIdentifier: AccountContactType,
        managedNotificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateManagedNotificationAccountContactResponse {
        let input = AssociateManagedNotificationAccountContactRequest(
            contactIdentifier: contactIdentifier, 
            managedNotificationConfigurationArn: managedNotificationConfigurationArn
        )
        return try await self.associateManagedNotificationAccountContact(input, logger: logger)
    }

    /// Associates an additional Channel with a particular ManagedNotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, the Console Mobile Application, and emails (notifications-contacts).
    @Sendable
    @inlinable
    public func associateManagedNotificationAdditionalChannel(_ input: AssociateManagedNotificationAdditionalChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateManagedNotificationAdditionalChannelResponse {
        try await self.client.execute(
            operation: "AssociateManagedNotificationAdditionalChannel", 
            path: "/channels/associate-managed-notification/{channelArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates an additional Channel with a particular ManagedNotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, the Console Mobile Application, and emails (notifications-contacts).
    ///
    /// Parameters:
    ///   - channelArn: The Amazon Resource Name (ARN) of the Channel to associate with the ManagedNotificationConfiguration. Supported ARNs include Amazon Q Developer in chat applications, the Console Mobile Application, and email (notifications-contacts).
    ///   - managedNotificationConfigurationArn: The Amazon Resource Name (ARN) of the ManagedNotificationConfiguration to associate with the additional Channel.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateManagedNotificationAdditionalChannel(
        channelArn: String,
        managedNotificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateManagedNotificationAdditionalChannelResponse {
        let input = AssociateManagedNotificationAdditionalChannelRequest(
            channelArn: channelArn, 
            managedNotificationConfigurationArn: managedNotificationConfigurationArn
        )
        return try await self.associateManagedNotificationAdditionalChannel(input, logger: logger)
    }

    /// Associates an organizational unit with a notification configuration.
    @Sendable
    @inlinable
    public func associateOrganizationalUnit(_ input: AssociateOrganizationalUnitRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateOrganizationalUnitResponse {
        try await self.client.execute(
            operation: "AssociateOrganizationalUnit", 
            path: "/organizational-units/associate/{organizationalUnitId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates an organizational unit with a notification configuration.
    ///
    /// Parameters:
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the notification configuration to associate with the organizational unit.
    ///   - organizationalUnitId: The unique identifier of the organizational unit to associate.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateOrganizationalUnit(
        notificationConfigurationArn: String,
        organizationalUnitId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateOrganizationalUnitResponse {
        let input = AssociateOrganizationalUnitRequest(
            notificationConfigurationArn: notificationConfigurationArn, 
            organizationalUnitId: organizationalUnitId
        )
        return try await self.associateOrganizationalUnit(input, logger: logger)
    }

    /// Creates an  EventRule  that is associated with a specified NotificationConfiguration.
    @Sendable
    @inlinable
    public func createEventRule(_ input: CreateEventRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEventRuleResponse {
        try await self.client.execute(
            operation: "CreateEventRule", 
            path: "/event-rules", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an  EventRule  that is associated with a specified NotificationConfiguration.
    ///
    /// Parameters:
    ///   - eventPattern: An additional event pattern used to further filter the events this EventRule receives. For more information, see Amazon EventBridge event patterns in the Amazon EventBridge User Guide.
    ///   - eventType: The event type to match. Must match one of the valid Amazon EventBridge event types. For example, EC2 Instance State-change Notification and Amazon CloudWatch Alarm State Change. For more information, see Event delivery from Amazon Web Services services in the Amazon EventBridge User Guide.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the NotificationConfiguration associated with this EventRule.
    ///   - regions: A list of Amazon Web Services Regions that send events to this EventRule.
    ///   - source: The matched event source. Must match one of the valid EventBridge sources. Only Amazon Web Services service sourced events are supported. For example, aws.ec2 and aws.cloudwatch. For more information, see Event delivery from Amazon Web Services services in the Amazon EventBridge User Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEventRule(
        eventPattern: String? = nil,
        eventType: String,
        notificationConfigurationArn: String,
        regions: [String],
        source: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEventRuleResponse {
        let input = CreateEventRuleRequest(
            eventPattern: eventPattern, 
            eventType: eventType, 
            notificationConfigurationArn: notificationConfigurationArn, 
            regions: regions, 
            source: source
        )
        return try await self.createEventRule(input, logger: logger)
    }

    /// Creates a new NotificationConfiguration.
    @Sendable
    @inlinable
    public func createNotificationConfiguration(_ input: CreateNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNotificationConfigurationResponse {
        try await self.client.execute(
            operation: "CreateNotificationConfiguration", 
            path: "/notification-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new NotificationConfiguration.
    ///
    /// Parameters:
    ///   - aggregationDuration: The aggregation preference of the NotificationConfiguration.   Values:    LONG    Aggregate notifications for long periods of time (12 hours).      SHORT    Aggregate notifications for short periods of time (5 minutes).      NONE    Don't aggregate notifications.
    ///   - description: The description of the NotificationConfiguration.
    ///   - name: The name of the NotificationConfiguration. Supports RFC 3986's unreserved characters.
    ///   - tags: A map of tags assigned to a resource. A tag is a string-to-string map of key-value pairs.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNotificationConfiguration(
        aggregationDuration: AggregationDuration? = nil,
        description: String,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNotificationConfigurationResponse {
        let input = CreateNotificationConfigurationRequest(
            aggregationDuration: aggregationDuration, 
            description: description, 
            name: name, 
            tags: tags
        )
        return try await self.createNotificationConfiguration(input, logger: logger)
    }

    /// Deletes an EventRule.
    @Sendable
    @inlinable
    public func deleteEventRule(_ input: DeleteEventRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEventRuleResponse {
        try await self.client.execute(
            operation: "DeleteEventRule", 
            path: "/event-rules/{arn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an EventRule.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the EventRule to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEventRule(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEventRuleResponse {
        let input = DeleteEventRuleRequest(
            arn: arn
        )
        return try await self.deleteEventRule(input, logger: logger)
    }

    /// Deletes a NotificationConfiguration.
    @Sendable
    @inlinable
    public func deleteNotificationConfiguration(_ input: DeleteNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNotificationConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteNotificationConfiguration", 
            path: "/notification-configurations/{arn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a NotificationConfiguration.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the NotificationConfiguration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNotificationConfiguration(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNotificationConfigurationResponse {
        let input = DeleteNotificationConfigurationRequest(
            arn: arn
        )
        return try await self.deleteNotificationConfiguration(input, logger: logger)
    }

    /// Deregisters a NotificationConfiguration in the specified Region.  You can't deregister the last NotificationHub in the account. NotificationEvents stored in the deregistered NotificationConfiguration are no longer be visible. Recreating a new NotificationConfiguration in the same Region restores access to those NotificationEvents.
    @Sendable
    @inlinable
    public func deregisterNotificationHub(_ input: DeregisterNotificationHubRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeregisterNotificationHubResponse {
        try await self.client.execute(
            operation: "DeregisterNotificationHub", 
            path: "/notification-hubs/{notificationHubRegion}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deregisters a NotificationConfiguration in the specified Region.  You can't deregister the last NotificationHub in the account. NotificationEvents stored in the deregistered NotificationConfiguration are no longer be visible. Recreating a new NotificationConfiguration in the same Region restores access to those NotificationEvents.
    ///
    /// Parameters:
    ///   - notificationHubRegion: The NotificationConfiguration Region.
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterNotificationHub(
        notificationHubRegion: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeregisterNotificationHubResponse {
        let input = DeregisterNotificationHubRequest(
            notificationHubRegion: notificationHubRegion
        )
        return try await self.deregisterNotificationHub(input, logger: logger)
    }

    /// Disables service trust between User Notifications and Amazon Web Services Organizations.
    @Sendable
    @inlinable
    public func disableNotificationsAccessForOrganization(_ input: DisableNotificationsAccessForOrganizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisableNotificationsAccessForOrganizationResponse {
        try await self.client.execute(
            operation: "DisableNotificationsAccessForOrganization", 
            path: "/organization/access", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables service trust between User Notifications and Amazon Web Services Organizations.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func disableNotificationsAccessForOrganization(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisableNotificationsAccessForOrganizationResponse {
        let input = DisableNotificationsAccessForOrganizationRequest(
        )
        return try await self.disableNotificationsAccessForOrganization(input, logger: logger)
    }

    /// Disassociates a Channel from a specified NotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, the Console Mobile Application, and emails (notifications-contacts).
    @Sendable
    @inlinable
    public func disassociateChannel(_ input: DisassociateChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateChannelResponse {
        try await self.client.execute(
            operation: "DisassociateChannel", 
            path: "/channels/disassociate/{arn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a Channel from a specified NotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, the Console Mobile Application, and emails (notifications-contacts).
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the Channel to disassociate.
    ///   - notificationConfigurationArn: The ARN of the NotificationConfiguration to disassociate.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateChannel(
        arn: String,
        notificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateChannelResponse {
        let input = DisassociateChannelRequest(
            arn: arn, 
            notificationConfigurationArn: notificationConfigurationArn
        )
        return try await self.disassociateChannel(input, logger: logger)
    }

    /// Disassociates an Account Contact with a particular ManagedNotificationConfiguration.
    @Sendable
    @inlinable
    public func disassociateManagedNotificationAccountContact(_ input: DisassociateManagedNotificationAccountContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateManagedNotificationAccountContactResponse {
        try await self.client.execute(
            operation: "DisassociateManagedNotificationAccountContact", 
            path: "/contacts/disassociate-managed-notification/{contactIdentifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates an Account Contact with a particular ManagedNotificationConfiguration.
    ///
    /// Parameters:
    ///   - contactIdentifier: The unique value of an Account Contact Type to associate with the ManagedNotificationConfiguration.
    ///   - managedNotificationConfigurationArn: The Amazon Resource Name (ARN) of the ManagedNotificationConfiguration to associate with the Account Contact.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateManagedNotificationAccountContact(
        contactIdentifier: AccountContactType,
        managedNotificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateManagedNotificationAccountContactResponse {
        let input = DisassociateManagedNotificationAccountContactRequest(
            contactIdentifier: contactIdentifier, 
            managedNotificationConfigurationArn: managedNotificationConfigurationArn
        )
        return try await self.disassociateManagedNotificationAccountContact(input, logger: logger)
    }

    /// Disassociates an additional Channel from a particular ManagedNotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, the Console Mobile Application, and emails (notifications-contacts).
    @Sendable
    @inlinable
    public func disassociateManagedNotificationAdditionalChannel(_ input: DisassociateManagedNotificationAdditionalChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateManagedNotificationAdditionalChannelResponse {
        try await self.client.execute(
            operation: "DisassociateManagedNotificationAdditionalChannel", 
            path: "/channels/disassociate-managed-notification/{channelArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates an additional Channel from a particular ManagedNotificationConfiguration. Supported Channels include Amazon Q Developer in chat applications, the Console Mobile Application, and emails (notifications-contacts).
    ///
    /// Parameters:
    ///   - channelArn: The Amazon Resource Name (ARN) of the Channel to associate with the ManagedNotificationConfiguration.
    ///   - managedNotificationConfigurationArn: The Amazon Resource Name (ARN) of the Managed Notification Configuration to associate with the additional Channel.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateManagedNotificationAdditionalChannel(
        channelArn: String,
        managedNotificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateManagedNotificationAdditionalChannelResponse {
        let input = DisassociateManagedNotificationAdditionalChannelRequest(
            channelArn: channelArn, 
            managedNotificationConfigurationArn: managedNotificationConfigurationArn
        )
        return try await self.disassociateManagedNotificationAdditionalChannel(input, logger: logger)
    }

    /// Removes the association between an organizational unit and a notification configuration.
    @Sendable
    @inlinable
    public func disassociateOrganizationalUnit(_ input: DisassociateOrganizationalUnitRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateOrganizationalUnitResponse {
        try await self.client.execute(
            operation: "DisassociateOrganizationalUnit", 
            path: "/organizational-units/disassociate/{organizationalUnitId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the association between an organizational unit and a notification configuration.
    ///
    /// Parameters:
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the notification configuration to disassociate from the organizational unit.
    ///   - organizationalUnitId: The unique identifier of the organizational unit to disassociate.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateOrganizationalUnit(
        notificationConfigurationArn: String,
        organizationalUnitId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateOrganizationalUnitResponse {
        let input = DisassociateOrganizationalUnitRequest(
            notificationConfigurationArn: notificationConfigurationArn, 
            organizationalUnitId: organizationalUnitId
        )
        return try await self.disassociateOrganizationalUnit(input, logger: logger)
    }

    /// Enables service trust between User Notifications and Amazon Web Services Organizations.
    @Sendable
    @inlinable
    public func enableNotificationsAccessForOrganization(_ input: EnableNotificationsAccessForOrganizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EnableNotificationsAccessForOrganizationResponse {
        try await self.client.execute(
            operation: "EnableNotificationsAccessForOrganization", 
            path: "/organization/access", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables service trust between User Notifications and Amazon Web Services Organizations.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func enableNotificationsAccessForOrganization(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EnableNotificationsAccessForOrganizationResponse {
        let input = EnableNotificationsAccessForOrganizationRequest(
        )
        return try await self.enableNotificationsAccessForOrganization(input, logger: logger)
    }

    /// Returns a specified EventRule.
    @Sendable
    @inlinable
    public func getEventRule(_ input: GetEventRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEventRuleResponse {
        try await self.client.execute(
            operation: "GetEventRule", 
            path: "/event-rules/{arn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a specified EventRule.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the EventRule to return.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEventRule(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEventRuleResponse {
        let input = GetEventRuleRequest(
            arn: arn
        )
        return try await self.getEventRule(input, logger: logger)
    }

    /// Returns the child event of a specific given ManagedNotificationEvent.
    @Sendable
    @inlinable
    public func getManagedNotificationChildEvent(_ input: GetManagedNotificationChildEventRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetManagedNotificationChildEventResponse {
        try await self.client.execute(
            operation: "GetManagedNotificationChildEvent", 
            path: "/managed-notification-child-events/{arn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the child event of a specific given ManagedNotificationEvent.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the ManagedNotificationChildEvent to return.
    ///   - locale: The locale code of the language used for the retrieved ManagedNotificationChildEvent. The default locale is English en_US.
    ///   - logger: Logger use during operation
    @inlinable
    public func getManagedNotificationChildEvent(
        arn: String,
        locale: LocaleCode? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetManagedNotificationChildEventResponse {
        let input = GetManagedNotificationChildEventRequest(
            arn: arn, 
            locale: locale
        )
        return try await self.getManagedNotificationChildEvent(input, logger: logger)
    }

    /// Returns a specified ManagedNotificationConfiguration.
    @Sendable
    @inlinable
    public func getManagedNotificationConfiguration(_ input: GetManagedNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetManagedNotificationConfigurationResponse {
        try await self.client.execute(
            operation: "GetManagedNotificationConfiguration", 
            path: "/managed-notification-configurations/{arn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a specified ManagedNotificationConfiguration.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the ManagedNotificationConfiguration to return.
    ///   - logger: Logger use during operation
    @inlinable
    public func getManagedNotificationConfiguration(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetManagedNotificationConfigurationResponse {
        let input = GetManagedNotificationConfigurationRequest(
            arn: arn
        )
        return try await self.getManagedNotificationConfiguration(input, logger: logger)
    }

    /// Returns a specified ManagedNotificationEvent.
    @Sendable
    @inlinable
    public func getManagedNotificationEvent(_ input: GetManagedNotificationEventRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetManagedNotificationEventResponse {
        try await self.client.execute(
            operation: "GetManagedNotificationEvent", 
            path: "/managed-notification-events/{arn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a specified ManagedNotificationEvent.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the ManagedNotificationEvent to return.
    ///   - locale: The locale code of the language used for the retrieved ManagedNotificationEvent. The default locale is English (en_US).
    ///   - logger: Logger use during operation
    @inlinable
    public func getManagedNotificationEvent(
        arn: String,
        locale: LocaleCode? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetManagedNotificationEventResponse {
        let input = GetManagedNotificationEventRequest(
            arn: arn, 
            locale: locale
        )
        return try await self.getManagedNotificationEvent(input, logger: logger)
    }

    /// Returns a specified NotificationConfiguration.
    @Sendable
    @inlinable
    public func getNotificationConfiguration(_ input: GetNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNotificationConfigurationResponse {
        try await self.client.execute(
            operation: "GetNotificationConfiguration", 
            path: "/notification-configurations/{arn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a specified NotificationConfiguration.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the NotificationConfiguration to return.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNotificationConfiguration(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNotificationConfigurationResponse {
        let input = GetNotificationConfigurationRequest(
            arn: arn
        )
        return try await self.getNotificationConfiguration(input, logger: logger)
    }

    /// Returns a specified NotificationEvent.  User Notifications stores notifications in the individual Regions you register as notification hubs and the Region of the source event rule. GetNotificationEvent only returns notifications stored in the same Region in which the action is called. User Notifications doesn't backfill notifications to new Regions selected as notification hubs. For this reason, we recommend that you make calls in your oldest registered notification hub. For more information, see Notification hubs in the Amazon Web Services User Notifications User Guide.
    @Sendable
    @inlinable
    public func getNotificationEvent(_ input: GetNotificationEventRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNotificationEventResponse {
        try await self.client.execute(
            operation: "GetNotificationEvent", 
            path: "/notification-events/{arn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a specified NotificationEvent.  User Notifications stores notifications in the individual Regions you register as notification hubs and the Region of the source event rule. GetNotificationEvent only returns notifications stored in the same Region in which the action is called. User Notifications doesn't backfill notifications to new Regions selected as notification hubs. For this reason, we recommend that you make calls in your oldest registered notification hub. For more information, see Notification hubs in the Amazon Web Services User Notifications User Guide.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) of the NotificationEvent to return.
    ///   - locale: The locale code of the language used for the retrieved NotificationEvent. The default locale is English en_US.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNotificationEvent(
        arn: String,
        locale: LocaleCode? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNotificationEventResponse {
        let input = GetNotificationEventRequest(
            arn: arn, 
            locale: locale
        )
        return try await self.getNotificationEvent(input, logger: logger)
    }

    /// Returns the AccessStatus of Service Trust Enablement for User Notifications and Amazon Web Services Organizations.
    @Sendable
    @inlinable
    public func getNotificationsAccessForOrganization(_ input: GetNotificationsAccessForOrganizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNotificationsAccessForOrganizationResponse {
        try await self.client.execute(
            operation: "GetNotificationsAccessForOrganization", 
            path: "/organization/access", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the AccessStatus of Service Trust Enablement for User Notifications and Amazon Web Services Organizations.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getNotificationsAccessForOrganization(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNotificationsAccessForOrganizationResponse {
        let input = GetNotificationsAccessForOrganizationRequest(
        )
        return try await self.getNotificationsAccessForOrganization(input, logger: logger)
    }

    /// Returns a list of Channels for a NotificationConfiguration.
    @Sendable
    @inlinable
    public func listChannels(_ input: ListChannelsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListChannelsResponse {
        try await self.client.execute(
            operation: "ListChannels", 
            path: "/channels", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of Channels for a NotificationConfiguration.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned in this call. The default value is 20.
    ///   - nextToken: The start token for paginated calls. Retrieved from the response of a previous ListNotificationEvents call. NextToken uses Base64 encoding.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the NotificationConfiguration.
    ///   - logger: Logger use during operation
    @inlinable
    public func listChannels(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        notificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListChannelsResponse {
        let input = ListChannelsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            notificationConfigurationArn: notificationConfigurationArn
        )
        return try await self.listChannels(input, logger: logger)
    }

    /// Returns a list of EventRules according to specified filters, in reverse chronological order (newest first).
    @Sendable
    @inlinable
    public func listEventRules(_ input: ListEventRulesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEventRulesResponse {
        try await self.client.execute(
            operation: "ListEventRules", 
            path: "/event-rules", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of EventRules according to specified filters, in reverse chronological order (newest first).
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned in this call. The default value is 20.
    ///   - nextToken: The start token for paginated calls. Retrieved from the response of a previous ListEventRules call. Next token uses Base64 encoding.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the NotificationConfiguration.
    ///   - logger: Logger use during operation
    @inlinable
    public func listEventRules(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        notificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEventRulesResponse {
        let input = ListEventRulesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            notificationConfigurationArn: notificationConfigurationArn
        )
        return try await self.listEventRules(input, logger: logger)
    }

    /// Returns a list of Account contacts and Channels associated with a ManagedNotificationConfiguration, in paginated format.
    @Sendable
    @inlinable
    public func listManagedNotificationChannelAssociations(_ input: ListManagedNotificationChannelAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedNotificationChannelAssociationsResponse {
        try await self.client.execute(
            operation: "ListManagedNotificationChannelAssociations", 
            path: "/channels/list-managed-notification-channel-associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of Account contacts and Channels associated with a ManagedNotificationConfiguration, in paginated format.
    ///
    /// Parameters:
    ///   - managedNotificationConfigurationArn: The Amazon Resource Name (ARN) of the ManagedNotificationConfiguration to match.
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - nextToken: The start token for paginated calls. Retrieved from the response of a previous ListManagedNotificationChannelAssociations call.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedNotificationChannelAssociations(
        managedNotificationConfigurationArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedNotificationChannelAssociationsResponse {
        let input = ListManagedNotificationChannelAssociationsRequest(
            managedNotificationConfigurationArn: managedNotificationConfigurationArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listManagedNotificationChannelAssociations(input, logger: logger)
    }

    /// Returns a list of ManagedNotificationChildEvents for a specified aggregate ManagedNotificationEvent, ordered by creation time in reverse chronological order (newest first).
    @Sendable
    @inlinable
    public func listManagedNotificationChildEvents(_ input: ListManagedNotificationChildEventsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedNotificationChildEventsResponse {
        try await self.client.execute(
            operation: "ListManagedNotificationChildEvents", 
            path: "/list-managed-notification-child-events/{aggregateManagedNotificationEventArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of ManagedNotificationChildEvents for a specified aggregate ManagedNotificationEvent, ordered by creation time in reverse chronological order (newest first).
    ///
    /// Parameters:
    ///   - aggregateManagedNotificationEventArn: The Amazon Resource Name (ARN) of the ManagedNotificationEvent.
    ///   - endTime: Latest time of events to return from this call.
    ///   - locale: The locale code of the language used for the retrieved NotificationEvent. The default locale is English.en_US.
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - nextToken: The start token for paginated calls. Retrieved from the response of a previous ListManagedNotificationChannelAssociations call. Next token uses Base64 encoding.
    ///   - organizationalUnitId: The identifier of the Amazon Web Services Organizations organizational unit (OU) associated with the Managed Notification Child Events.
    ///   - relatedAccount: The Amazon Web Services account ID associated with the Managed Notification Child Events.
    ///   - startTime: The earliest time of events to return from this call.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedNotificationChildEvents(
        aggregateManagedNotificationEventArn: String,
        endTime: Date? = nil,
        locale: LocaleCode? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        organizationalUnitId: String? = nil,
        relatedAccount: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedNotificationChildEventsResponse {
        let input = ListManagedNotificationChildEventsRequest(
            aggregateManagedNotificationEventArn: aggregateManagedNotificationEventArn, 
            endTime: endTime, 
            locale: locale, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            organizationalUnitId: organizationalUnitId, 
            relatedAccount: relatedAccount, 
            startTime: startTime
        )
        return try await self.listManagedNotificationChildEvents(input, logger: logger)
    }

    /// Returns a list of Managed Notification Configurations according to specified filters, ordered by creation time in reverse chronological order (newest first).
    @Sendable
    @inlinable
    public func listManagedNotificationConfigurations(_ input: ListManagedNotificationConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedNotificationConfigurationsResponse {
        try await self.client.execute(
            operation: "ListManagedNotificationConfigurations", 
            path: "/managed-notification-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of Managed Notification Configurations according to specified filters, ordered by creation time in reverse chronological order (newest first).
    ///
    /// Parameters:
    ///   - channelIdentifier: The identifier or ARN of the notification channel to filter configurations by.
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - nextToken: The start token for paginated calls. Retrieved from the response of a previous ListManagedNotificationChannelAssociations call. Next token uses Base64 encoding.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedNotificationConfigurations(
        channelIdentifier: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedNotificationConfigurationsResponse {
        let input = ListManagedNotificationConfigurationsRequest(
            channelIdentifier: channelIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listManagedNotificationConfigurations(input, logger: logger)
    }

    /// Returns a list of Managed Notification Events according to specified filters, ordered by creation time in reverse chronological order (newest first).
    @Sendable
    @inlinable
    public func listManagedNotificationEvents(_ input: ListManagedNotificationEventsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedNotificationEventsResponse {
        try await self.client.execute(
            operation: "ListManagedNotificationEvents", 
            path: "/managed-notification-events", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of Managed Notification Events according to specified filters, ordered by creation time in reverse chronological order (newest first).
    ///
    /// Parameters:
    ///   - endTime: Latest time of events to return from this call.
    ///   - locale: The locale code of the language used for the retrieved NotificationEvent. The default locale is English (en_US).
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - nextToken: The start token for paginated calls. Retrieved from the response of a previous ListManagedNotificationChannelAssociations call. Next token uses Base64 encoding.
    ///   - organizationalUnitId: The Organizational Unit Id that an Amazon Web Services account belongs to.
    ///   - relatedAccount: The Amazon Web Services account ID associated with the Managed Notification Events.
    ///   - source: The Amazon Web Services service the event originates from. For example aws.cloudwatch.
    ///   - startTime: The earliest time of events to return from this call.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedNotificationEvents(
        endTime: Date? = nil,
        locale: LocaleCode? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        organizationalUnitId: String? = nil,
        relatedAccount: String? = nil,
        source: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedNotificationEventsResponse {
        let input = ListManagedNotificationEventsRequest(
            endTime: endTime, 
            locale: locale, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            organizationalUnitId: organizationalUnitId, 
            relatedAccount: relatedAccount, 
            source: source, 
            startTime: startTime
        )
        return try await self.listManagedNotificationEvents(input, logger: logger)
    }

    /// Returns a list of member accounts associated with a notification configuration.
    @Sendable
    @inlinable
    public func listMemberAccounts(_ input: ListMemberAccountsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMemberAccountsResponse {
        try await self.client.execute(
            operation: "ListMemberAccounts", 
            path: "/list-member-accounts", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of member accounts associated with a notification configuration.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. Valid values are 1-100.
    ///   - memberAccount: The member account identifier used to filter the results.
    ///   - nextToken: The token for the next page of results. Use the value returned in the previous response.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the notification configuration used to filter the member accounts.
    ///   - organizationalUnitId: The organizational unit ID used to filter the member accounts.
    ///   - status: The status used to filter the member accounts.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMemberAccounts(
        maxResults: Int? = nil,
        memberAccount: String? = nil,
        nextToken: String? = nil,
        notificationConfigurationArn: String,
        organizationalUnitId: String? = nil,
        status: MemberAccountNotificationConfigurationStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMemberAccountsResponse {
        let input = ListMemberAccountsRequest(
            maxResults: maxResults, 
            memberAccount: memberAccount, 
            nextToken: nextToken, 
            notificationConfigurationArn: notificationConfigurationArn, 
            organizationalUnitId: organizationalUnitId, 
            status: status
        )
        return try await self.listMemberAccounts(input, logger: logger)
    }

    /// Returns a list of abbreviated NotificationConfigurations according to specified filters, in reverse chronological order (newest first).
    @Sendable
    @inlinable
    public func listNotificationConfigurations(_ input: ListNotificationConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNotificationConfigurationsResponse {
        try await self.client.execute(
            operation: "ListNotificationConfigurations", 
            path: "/notification-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of abbreviated NotificationConfigurations according to specified filters, in reverse chronological order (newest first).
    ///
    /// Parameters:
    ///   - channelArn: The Amazon Resource Name (ARN) of the Channel to match.
    ///   - eventRuleSource: The matched event source. Must match one of the valid EventBridge sources. Only Amazon Web Services service sourced events are supported. For example, aws.ec2 and aws.cloudwatch. For more information, see Event delivery from Amazon Web Services services in the Amazon EventBridge User Guide.
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - nextToken: The start token for paginated calls. Retrieved from the response of a previous ListEventRules call. Next token uses Base64 encoding.
    ///   - status: The NotificationConfiguration status to match.   Values:    ACTIVE    All EventRules are ACTIVE and any call can be run.      PARTIALLY_ACTIVE    Some EventRules are ACTIVE and some are INACTIVE. Any call can be run.   Any call can be run.      INACTIVE    All EventRules are INACTIVE and any call can be run.      DELETING    This NotificationConfiguration is being deleted.   Only GET and LIST calls can be run.
    ///   - subtype: The subtype used to filter the notification configurations in the request.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNotificationConfigurations(
        channelArn: String? = nil,
        eventRuleSource: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        status: NotificationConfigurationStatus? = nil,
        subtype: NotificationConfigurationSubtype? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNotificationConfigurationsResponse {
        let input = ListNotificationConfigurationsRequest(
            channelArn: channelArn, 
            eventRuleSource: eventRuleSource, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            status: status, 
            subtype: subtype
        )
        return try await self.listNotificationConfigurations(input, logger: logger)
    }

    /// Returns a list of NotificationEvents according to specified filters, in reverse chronological order (newest first).  User Notifications stores notifications in the individual Regions you register as notification hubs and the Region of the source event rule. ListNotificationEvents only returns notifications stored in the same Region in which the action is called. User Notifications doesn't backfill notifications to new Regions selected as notification hubs. For this reason, we recommend that you make calls in your oldest registered notification hub. For more information, see Notification hubs in the Amazon Web Services User Notifications User Guide.
    @Sendable
    @inlinable
    public func listNotificationEvents(_ input: ListNotificationEventsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNotificationEventsResponse {
        try await self.client.execute(
            operation: "ListNotificationEvents", 
            path: "/notification-events", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of NotificationEvents according to specified filters, in reverse chronological order (newest first).  User Notifications stores notifications in the individual Regions you register as notification hubs and the Region of the source event rule. ListNotificationEvents only returns notifications stored in the same Region in which the action is called. User Notifications doesn't backfill notifications to new Regions selected as notification hubs. For this reason, we recommend that you make calls in your oldest registered notification hub. For more information, see Notification hubs in the Amazon Web Services User Notifications User Guide.
    ///
    /// Parameters:
    ///   - aggregateNotificationEventArn: The Amazon Resource Name (ARN) of the aggregatedNotificationEventArn to match.
    ///   - endTime: Latest time of events to return from this call.
    ///   - includeChildEvents: Include aggregated child events in the result.
    ///   - locale: The locale code of the language used for the retrieved NotificationEvent. The default locale is English (en_US).
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - nextToken: The start token for paginated calls. Retrieved from the response of a previous ListEventRules call. Next token uses Base64 encoding.
    ///   - organizationalUnitId: The unique identifier of the organizational unit used to filter notification events.
    ///   - source: The matched event source. Must match one of the valid EventBridge sources. Only Amazon Web Services service sourced events are supported. For example, aws.ec2 and aws.cloudwatch. For more information, see Event delivery from Amazon Web Services services in the Amazon EventBridge User Guide.
    ///   - startTime: The earliest time of events to return from this call.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNotificationEvents(
        aggregateNotificationEventArn: String? = nil,
        endTime: Date? = nil,
        includeChildEvents: Bool? = nil,
        locale: LocaleCode? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        organizationalUnitId: String? = nil,
        source: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNotificationEventsResponse {
        let input = ListNotificationEventsRequest(
            aggregateNotificationEventArn: aggregateNotificationEventArn, 
            endTime: endTime, 
            includeChildEvents: includeChildEvents, 
            locale: locale, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            organizationalUnitId: organizationalUnitId, 
            source: source, 
            startTime: startTime
        )
        return try await self.listNotificationEvents(input, logger: logger)
    }

    /// Returns a list of NotificationHubs.
    @Sendable
    @inlinable
    public func listNotificationHubs(_ input: ListNotificationHubsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNotificationHubsResponse {
        try await self.client.execute(
            operation: "ListNotificationHubs", 
            path: "/notification-hubs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of NotificationHubs.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of records to list in a single response.
    ///   - nextToken: A pagination token. Set to null to start listing notification hubs from the start.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNotificationHubs(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNotificationHubsResponse {
        let input = ListNotificationHubsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listNotificationHubs(input, logger: logger)
    }

    /// Returns a list of organizational units associated with a notification configuration.
    @Sendable
    @inlinable
    public func listOrganizationalUnits(_ input: ListOrganizationalUnitsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOrganizationalUnitsResponse {
        try await self.client.execute(
            operation: "ListOrganizationalUnits", 
            path: "/organizational-units", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of organizational units associated with a notification configuration.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of organizational units to return in a single call. Valid values are 1-100.
    ///   - nextToken: The token for the next page of results. Use the value returned in the previous response.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the notification configuration used to filter the organizational units.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOrganizationalUnits(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        notificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOrganizationalUnitsResponse {
        let input = ListOrganizationalUnitsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            notificationConfigurationArn: notificationConfigurationArn
        )
        return try await self.listOrganizationalUnits(input, logger: logger)
    }

    /// Returns a list of tags for a specified Amazon Resource Name (ARN). For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.  This is only supported for NotificationConfigurations.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{arn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of tags for a specified Amazon Resource Name (ARN). For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.  This is only supported for NotificationConfigurations.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) to use to list tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            arn: arn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Registers a NotificationConfiguration in the specified Region. There is a maximum of one NotificationConfiguration per Region. You can have a maximum of 3 NotificationHub resources at a time.
    @Sendable
    @inlinable
    public func registerNotificationHub(_ input: RegisterNotificationHubRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterNotificationHubResponse {
        try await self.client.execute(
            operation: "RegisterNotificationHub", 
            path: "/notification-hubs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Registers a NotificationConfiguration in the specified Region. There is a maximum of one NotificationConfiguration per Region. You can have a maximum of 3 NotificationHub resources at a time.
    ///
    /// Parameters:
    ///   - notificationHubRegion: The Region of the NotificationHub.
    ///   - logger: Logger use during operation
    @inlinable
    public func registerNotificationHub(
        notificationHubRegion: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterNotificationHubResponse {
        let input = RegisterNotificationHubRequest(
            notificationHubRegion: notificationHubRegion
        )
        return try await self.registerNotificationHub(input, logger: logger)
    }

    /// Tags the resource with a tag key and value. For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.  This is only supported for NotificationConfigurations.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{arn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Tags the resource with a tag key and value. For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.  This is only supported for NotificationConfigurations.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) to use to tag a resource.
    ///   - tags: A map of tags assigned to a resource. A tag is a string-to-string map of key-value pairs.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        arn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            arn: arn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Untags a resource with a specified Amazon Resource Name (ARN). For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{arn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Untags a resource with a specified Amazon Resource Name (ARN). For more information, see Tagging your Amazon Web Services resources in the Tagging Amazon Web Services Resources User Guide.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) to use to untag a resource.
    ///   - tagKeys: The tag keys to use to untag a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        arn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            arn: arn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates an existing EventRule.
    @Sendable
    @inlinable
    public func updateEventRule(_ input: UpdateEventRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEventRuleResponse {
        try await self.client.execute(
            operation: "UpdateEventRule", 
            path: "/event-rules/{arn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing EventRule.
    ///
    /// Parameters:
    ///   - arn: The Amazon Resource Name (ARN) to use to update the EventRule.
    ///   - eventPattern: An additional event pattern used to further filter the events this EventRule receives. For more information, see Amazon EventBridge event patterns in the Amazon EventBridge User Guide.
    ///   - regions: A list of Amazon Web Services Regions that sends events to this EventRule.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEventRule(
        arn: String,
        eventPattern: String? = nil,
        regions: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEventRuleResponse {
        let input = UpdateEventRuleRequest(
            arn: arn, 
            eventPattern: eventPattern, 
            regions: regions
        )
        return try await self.updateEventRule(input, logger: logger)
    }

    /// Updates a NotificationConfiguration.
    @Sendable
    @inlinable
    public func updateNotificationConfiguration(_ input: UpdateNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNotificationConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateNotificationConfiguration", 
            path: "/notification-configurations/{arn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a NotificationConfiguration.
    ///
    /// Parameters:
    ///   - aggregationDuration: The aggregation preference of the NotificationConfiguration.   Values:    LONG    Aggregate notifications for long periods of time (12 hours).      SHORT    Aggregate notifications for short periods of time (5 minutes).      NONE    Don't aggregate notifications.
    ///   - arn: The Amazon Resource Name (ARN) used to update the NotificationConfiguration.
    ///   - description: The description of the NotificationConfiguration.
    ///   - name: The name of the NotificationConfiguration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNotificationConfiguration(
        aggregationDuration: AggregationDuration? = nil,
        arn: String,
        description: String? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNotificationConfigurationResponse {
        let input = UpdateNotificationConfigurationRequest(
            aggregationDuration: aggregationDuration, 
            arn: arn, 
            description: description, 
            name: name
        )
        return try await self.updateNotificationConfiguration(input, logger: logger)
    }
}

extension Notifications {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Notifications, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Notifications {
    /// Return PaginatorSequence for operation ``listChannels(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listChannelsPaginator(
        _ input: ListChannelsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListChannelsRequest, ListChannelsResponse> {
        return .init(
            input: input,
            command: self.listChannels,
            inputKey: \ListChannelsRequest.nextToken,
            outputKey: \ListChannelsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listChannels(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be returned in this call. The default value is 20.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the NotificationConfiguration.
    ///   - logger: Logger used for logging
    @inlinable
    public func listChannelsPaginator(
        maxResults: Int? = nil,
        notificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListChannelsRequest, ListChannelsResponse> {
        let input = ListChannelsRequest(
            maxResults: maxResults, 
            notificationConfigurationArn: notificationConfigurationArn
        )
        return self.listChannelsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listEventRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listEventRulesPaginator(
        _ input: ListEventRulesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListEventRulesRequest, ListEventRulesResponse> {
        return .init(
            input: input,
            command: self.listEventRules,
            inputKey: \ListEventRulesRequest.nextToken,
            outputKey: \ListEventRulesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listEventRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to be returned in this call. The default value is 20.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the NotificationConfiguration.
    ///   - logger: Logger used for logging
    @inlinable
    public func listEventRulesPaginator(
        maxResults: Int? = nil,
        notificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListEventRulesRequest, ListEventRulesResponse> {
        let input = ListEventRulesRequest(
            maxResults: maxResults, 
            notificationConfigurationArn: notificationConfigurationArn
        )
        return self.listEventRulesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedNotificationChannelAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedNotificationChannelAssociationsPaginator(
        _ input: ListManagedNotificationChannelAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedNotificationChannelAssociationsRequest, ListManagedNotificationChannelAssociationsResponse> {
        return .init(
            input: input,
            command: self.listManagedNotificationChannelAssociations,
            inputKey: \ListManagedNotificationChannelAssociationsRequest.nextToken,
            outputKey: \ListManagedNotificationChannelAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedNotificationChannelAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - managedNotificationConfigurationArn: The Amazon Resource Name (ARN) of the ManagedNotificationConfiguration to match.
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedNotificationChannelAssociationsPaginator(
        managedNotificationConfigurationArn: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedNotificationChannelAssociationsRequest, ListManagedNotificationChannelAssociationsResponse> {
        let input = ListManagedNotificationChannelAssociationsRequest(
            managedNotificationConfigurationArn: managedNotificationConfigurationArn, 
            maxResults: maxResults
        )
        return self.listManagedNotificationChannelAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedNotificationChildEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedNotificationChildEventsPaginator(
        _ input: ListManagedNotificationChildEventsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedNotificationChildEventsRequest, ListManagedNotificationChildEventsResponse> {
        return .init(
            input: input,
            command: self.listManagedNotificationChildEvents,
            inputKey: \ListManagedNotificationChildEventsRequest.nextToken,
            outputKey: \ListManagedNotificationChildEventsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedNotificationChildEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - aggregateManagedNotificationEventArn: The Amazon Resource Name (ARN) of the ManagedNotificationEvent.
    ///   - endTime: Latest time of events to return from this call.
    ///   - locale: The locale code of the language used for the retrieved NotificationEvent. The default locale is English.en_US.
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - organizationalUnitId: The identifier of the Amazon Web Services Organizations organizational unit (OU) associated with the Managed Notification Child Events.
    ///   - relatedAccount: The Amazon Web Services account ID associated with the Managed Notification Child Events.
    ///   - startTime: The earliest time of events to return from this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedNotificationChildEventsPaginator(
        aggregateManagedNotificationEventArn: String,
        endTime: Date? = nil,
        locale: LocaleCode? = nil,
        maxResults: Int? = nil,
        organizationalUnitId: String? = nil,
        relatedAccount: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedNotificationChildEventsRequest, ListManagedNotificationChildEventsResponse> {
        let input = ListManagedNotificationChildEventsRequest(
            aggregateManagedNotificationEventArn: aggregateManagedNotificationEventArn, 
            endTime: endTime, 
            locale: locale, 
            maxResults: maxResults, 
            organizationalUnitId: organizationalUnitId, 
            relatedAccount: relatedAccount, 
            startTime: startTime
        )
        return self.listManagedNotificationChildEventsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedNotificationConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedNotificationConfigurationsPaginator(
        _ input: ListManagedNotificationConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedNotificationConfigurationsRequest, ListManagedNotificationConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listManagedNotificationConfigurations,
            inputKey: \ListManagedNotificationConfigurationsRequest.nextToken,
            outputKey: \ListManagedNotificationConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedNotificationConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - channelIdentifier: The identifier or ARN of the notification channel to filter configurations by.
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedNotificationConfigurationsPaginator(
        channelIdentifier: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedNotificationConfigurationsRequest, ListManagedNotificationConfigurationsResponse> {
        let input = ListManagedNotificationConfigurationsRequest(
            channelIdentifier: channelIdentifier, 
            maxResults: maxResults
        )
        return self.listManagedNotificationConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedNotificationEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedNotificationEventsPaginator(
        _ input: ListManagedNotificationEventsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedNotificationEventsRequest, ListManagedNotificationEventsResponse> {
        return .init(
            input: input,
            command: self.listManagedNotificationEvents,
            inputKey: \ListManagedNotificationEventsRequest.nextToken,
            outputKey: \ListManagedNotificationEventsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedNotificationEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endTime: Latest time of events to return from this call.
    ///   - locale: The locale code of the language used for the retrieved NotificationEvent. The default locale is English (en_US).
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - organizationalUnitId: The Organizational Unit Id that an Amazon Web Services account belongs to.
    ///   - relatedAccount: The Amazon Web Services account ID associated with the Managed Notification Events.
    ///   - source: The Amazon Web Services service the event originates from. For example aws.cloudwatch.
    ///   - startTime: The earliest time of events to return from this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedNotificationEventsPaginator(
        endTime: Date? = nil,
        locale: LocaleCode? = nil,
        maxResults: Int? = nil,
        organizationalUnitId: String? = nil,
        relatedAccount: String? = nil,
        source: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedNotificationEventsRequest, ListManagedNotificationEventsResponse> {
        let input = ListManagedNotificationEventsRequest(
            endTime: endTime, 
            locale: locale, 
            maxResults: maxResults, 
            organizationalUnitId: organizationalUnitId, 
            relatedAccount: relatedAccount, 
            source: source, 
            startTime: startTime
        )
        return self.listManagedNotificationEventsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMemberAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMemberAccountsPaginator(
        _ input: ListMemberAccountsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMemberAccountsRequest, ListMemberAccountsResponse> {
        return .init(
            input: input,
            command: self.listMemberAccounts,
            inputKey: \ListMemberAccountsRequest.nextToken,
            outputKey: \ListMemberAccountsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMemberAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return in a single call. Valid values are 1-100.
    ///   - memberAccount: The member account identifier used to filter the results.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the notification configuration used to filter the member accounts.
    ///   - organizationalUnitId: The organizational unit ID used to filter the member accounts.
    ///   - status: The status used to filter the member accounts.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMemberAccountsPaginator(
        maxResults: Int? = nil,
        memberAccount: String? = nil,
        notificationConfigurationArn: String,
        organizationalUnitId: String? = nil,
        status: MemberAccountNotificationConfigurationStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMemberAccountsRequest, ListMemberAccountsResponse> {
        let input = ListMemberAccountsRequest(
            maxResults: maxResults, 
            memberAccount: memberAccount, 
            notificationConfigurationArn: notificationConfigurationArn, 
            organizationalUnitId: organizationalUnitId, 
            status: status
        )
        return self.listMemberAccountsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNotificationConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationConfigurationsPaginator(
        _ input: ListNotificationConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNotificationConfigurationsRequest, ListNotificationConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listNotificationConfigurations,
            inputKey: \ListNotificationConfigurationsRequest.nextToken,
            outputKey: \ListNotificationConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNotificationConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - channelArn: The Amazon Resource Name (ARN) of the Channel to match.
    ///   - eventRuleSource: The matched event source. Must match one of the valid EventBridge sources. Only Amazon Web Services service sourced events are supported. For example, aws.ec2 and aws.cloudwatch. For more information, see Event delivery from Amazon Web Services services in the Amazon EventBridge User Guide.
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - status: The NotificationConfiguration status to match.   Values:    ACTIVE    All EventRules are ACTIVE and any call can be run.      PARTIALLY_ACTIVE    Some EventRules are ACTIVE and some are INACTIVE. Any call can be run.   Any call can be run.      INACTIVE    All EventRules are INACTIVE and any call can be run.      DELETING    This NotificationConfiguration is being deleted.   Only GET and LIST calls can be run.
    ///   - subtype: The subtype used to filter the notification configurations in the request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationConfigurationsPaginator(
        channelArn: String? = nil,
        eventRuleSource: String? = nil,
        maxResults: Int? = nil,
        status: NotificationConfigurationStatus? = nil,
        subtype: NotificationConfigurationSubtype? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNotificationConfigurationsRequest, ListNotificationConfigurationsResponse> {
        let input = ListNotificationConfigurationsRequest(
            channelArn: channelArn, 
            eventRuleSource: eventRuleSource, 
            maxResults: maxResults, 
            status: status, 
            subtype: subtype
        )
        return self.listNotificationConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNotificationEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationEventsPaginator(
        _ input: ListNotificationEventsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNotificationEventsRequest, ListNotificationEventsResponse> {
        return .init(
            input: input,
            command: self.listNotificationEvents,
            inputKey: \ListNotificationEventsRequest.nextToken,
            outputKey: \ListNotificationEventsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNotificationEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - aggregateNotificationEventArn: The Amazon Resource Name (ARN) of the aggregatedNotificationEventArn to match.
    ///   - endTime: Latest time of events to return from this call.
    ///   - includeChildEvents: Include aggregated child events in the result.
    ///   - locale: The locale code of the language used for the retrieved NotificationEvent. The default locale is English (en_US).
    ///   - maxResults: The maximum number of results to be returned in this call. Defaults to 20.
    ///   - organizationalUnitId: The unique identifier of the organizational unit used to filter notification events.
    ///   - source: The matched event source. Must match one of the valid EventBridge sources. Only Amazon Web Services service sourced events are supported. For example, aws.ec2 and aws.cloudwatch. For more information, see Event delivery from Amazon Web Services services in the Amazon EventBridge User Guide.
    ///   - startTime: The earliest time of events to return from this call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationEventsPaginator(
        aggregateNotificationEventArn: String? = nil,
        endTime: Date? = nil,
        includeChildEvents: Bool? = nil,
        locale: LocaleCode? = nil,
        maxResults: Int? = nil,
        organizationalUnitId: String? = nil,
        source: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNotificationEventsRequest, ListNotificationEventsResponse> {
        let input = ListNotificationEventsRequest(
            aggregateNotificationEventArn: aggregateNotificationEventArn, 
            endTime: endTime, 
            includeChildEvents: includeChildEvents, 
            locale: locale, 
            maxResults: maxResults, 
            organizationalUnitId: organizationalUnitId, 
            source: source, 
            startTime: startTime
        )
        return self.listNotificationEventsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNotificationHubs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationHubsPaginator(
        _ input: ListNotificationHubsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNotificationHubsRequest, ListNotificationHubsResponse> {
        return .init(
            input: input,
            command: self.listNotificationHubs,
            inputKey: \ListNotificationHubsRequest.nextToken,
            outputKey: \ListNotificationHubsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNotificationHubs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of records to list in a single response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationHubsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNotificationHubsRequest, ListNotificationHubsResponse> {
        let input = ListNotificationHubsRequest(
            maxResults: maxResults
        )
        return self.listNotificationHubsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOrganizationalUnits(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOrganizationalUnitsPaginator(
        _ input: ListOrganizationalUnitsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOrganizationalUnitsRequest, ListOrganizationalUnitsResponse> {
        return .init(
            input: input,
            command: self.listOrganizationalUnits,
            inputKey: \ListOrganizationalUnitsRequest.nextToken,
            outputKey: \ListOrganizationalUnitsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOrganizationalUnits(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of organizational units to return in a single call. Valid values are 1-100.
    ///   - notificationConfigurationArn: The Amazon Resource Name (ARN) of the notification configuration used to filter the organizational units.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOrganizationalUnitsPaginator(
        maxResults: Int? = nil,
        notificationConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOrganizationalUnitsRequest, ListOrganizationalUnitsResponse> {
        let input = ListOrganizationalUnitsRequest(
            maxResults: maxResults, 
            notificationConfigurationArn: notificationConfigurationArn
        )
        return self.listOrganizationalUnitsPaginator(input, logger: logger)
    }
}

extension Notifications.ListChannelsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListChannelsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            notificationConfigurationArn: self.notificationConfigurationArn
        )
    }
}

extension Notifications.ListEventRulesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListEventRulesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            notificationConfigurationArn: self.notificationConfigurationArn
        )
    }
}

extension Notifications.ListManagedNotificationChannelAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListManagedNotificationChannelAssociationsRequest {
        return .init(
            managedNotificationConfigurationArn: self.managedNotificationConfigurationArn,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Notifications.ListManagedNotificationChildEventsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListManagedNotificationChildEventsRequest {
        return .init(
            aggregateManagedNotificationEventArn: self.aggregateManagedNotificationEventArn,
            endTime: self.endTime,
            locale: self.locale,
            maxResults: self.maxResults,
            nextToken: token,
            organizationalUnitId: self.organizationalUnitId,
            relatedAccount: self.relatedAccount,
            startTime: self.startTime
        )
    }
}

extension Notifications.ListManagedNotificationConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListManagedNotificationConfigurationsRequest {
        return .init(
            channelIdentifier: self.channelIdentifier,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Notifications.ListManagedNotificationEventsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListManagedNotificationEventsRequest {
        return .init(
            endTime: self.endTime,
            locale: self.locale,
            maxResults: self.maxResults,
            nextToken: token,
            organizationalUnitId: self.organizationalUnitId,
            relatedAccount: self.relatedAccount,
            source: self.source,
            startTime: self.startTime
        )
    }
}

extension Notifications.ListMemberAccountsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListMemberAccountsRequest {
        return .init(
            maxResults: self.maxResults,
            memberAccount: self.memberAccount,
            nextToken: token,
            notificationConfigurationArn: self.notificationConfigurationArn,
            organizationalUnitId: self.organizationalUnitId,
            status: self.status
        )
    }
}

extension Notifications.ListNotificationConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListNotificationConfigurationsRequest {
        return .init(
            channelArn: self.channelArn,
            eventRuleSource: self.eventRuleSource,
            maxResults: self.maxResults,
            nextToken: token,
            status: self.status,
            subtype: self.subtype
        )
    }
}

extension Notifications.ListNotificationEventsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListNotificationEventsRequest {
        return .init(
            aggregateNotificationEventArn: self.aggregateNotificationEventArn,
            endTime: self.endTime,
            includeChildEvents: self.includeChildEvents,
            locale: self.locale,
            maxResults: self.maxResults,
            nextToken: token,
            organizationalUnitId: self.organizationalUnitId,
            source: self.source,
            startTime: self.startTime
        )
    }
}

extension Notifications.ListNotificationHubsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListNotificationHubsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Notifications.ListOrganizationalUnitsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Notifications.ListOrganizationalUnitsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            notificationConfigurationArn: self.notificationConfigurationArn
        )
    }
}
